home *** CD-ROM | disk | FTP | other *** search
/ Kompuutteri K-CD 2002 #1 / K-CD_2002-01.iso / Delphi / INSTALL / program files / Borland / Delphi6 / Doc / ScktComp.int < prev    next >
Encoding:
Text File  |  2001-05-22  |  13.0 KB  |  356 lines
  1. { *********************************************************************** }
  2. {                                                                         }
  3. { Delphi Runtime Library                                                  }
  4. {                                                                         }
  5. { Copyright (c) 1997-2001 Borland Software Corporation                    }
  6. {                                                                         }
  7. { *********************************************************************** }
  8.  
  9. {*******************************************************}
  10. {       Windows socket components                       }
  11. {*******************************************************}
  12.  
  13. unit ScktComp;
  14.  
  15. interface
  16.  
  17. uses SysUtils, Windows, Messages, Classes, WinSock, SyncObjs;
  18.  
  19. const
  20.   CM_SOCKETMESSAGE = WM_USER + $0001;
  21.   CM_DEFERFREE = WM_USER + $0002;
  22.   CM_LOOKUPCOMPLETE = WM_USER + $0003;
  23.  
  24. type
  25.   ESocketError = class(Exception);
  26.  
  27.   TCMSocketMessage = record
  28.     Msg: Cardinal;
  29.     Socket: TSocket;
  30.     SelectEvent: Word;
  31.     SelectError: Word;
  32.     Result: Longint;
  33.   end;
  34.  
  35.   TCMLookupComplete = record
  36.     Msg: Cardinal;
  37.     LookupHandle: THandle;
  38.     AsyncBufLen: Word;
  39.     AsyncError: Word;
  40.     Result: Longint;
  41.   end;
  42.  
  43.   TCustomWinSocket = class;
  44.   TCustomSocket = class;
  45.   TServerAcceptThread = class;
  46.   TServerClientThread = class;
  47.   TServerWinSocket = class;
  48.   TServerClientWinSocket = class;
  49.  
  50.   TServerType = (stNonBlocking, stThreadBlocking);
  51.   TClientType = (ctNonBlocking, ctBlocking);
  52.   TAsyncStyle = (asRead, asWrite, asOOB, asAccept, asConnect, asClose);
  53.   TAsyncStyles = set of TAsyncStyle;
  54.   TSocketEvent = (seLookup, seConnecting, seConnect, seDisconnect, seListen,
  55.     seAccept, seWrite, seRead);
  56.   TLookupState = (lsIdle, lsLookupAddress, lsLookupService);
  57.   TErrorEvent = (eeGeneral, eeSend, eeReceive, eeConnect, eeDisconnect, eeAccept, eeLookup);
  58.  
  59.   TSocketEventEvent = procedure (Sender: TObject; Socket: TCustomWinSocket;
  60.     SocketEvent: TSocketEvent) of object;
  61.   TSocketErrorEvent = procedure (Sender: TObject; Socket: TCustomWinSocket;
  62.     ErrorEvent: TErrorEvent; var ErrorCode: Integer) of object;
  63.   TGetSocketEvent = procedure (Sender: TObject; Socket: TSocket;
  64.     var ClientSocket: TServerClientWinSocket) of object;
  65.   TGetThreadEvent = procedure (Sender: TObject; ClientSocket: TServerClientWinSocket;
  66.     var SocketThread: TServerClientThread) of object;
  67.   TSocketNotifyEvent = procedure (Sender: TObject; Socket: TCustomWinSocket) of object;
  68.  
  69.   TCustomWinSocket = class
  70.   protected
  71.     procedure AsyncInitSocket(const Name, Address, Service: string; Port: Word;
  72.       QueueSize: Integer; Client: Boolean);
  73.     procedure DoOpen;
  74.     procedure DoListen(QueueSize: Integer);
  75.     function InitSocket(const Name, Address, Service: string; Port: Word;
  76.       Client: Boolean): TSockAddrIn;
  77.     procedure Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent); dynamic;
  78.     procedure Error(Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
  79.       var ErrorCode: Integer); dynamic;
  80.     procedure SetAsyncStyles(Value: TASyncStyles);
  81.   public
  82.     constructor Create(ASocket: TSocket);
  83.     destructor Destroy; override;
  84.     procedure Close;
  85.     procedure DefaultHandler(var Message); override;
  86.     procedure Lock;
  87.     procedure Unlock;
  88.     procedure Listen(const Name, Address, Service: string; Port: Word;
  89.       QueueSize: Integer; Block: Boolean = True);
  90.     procedure Open(const Name, Address, Service: string; Port: Word; Block: Boolean = True);
  91.     procedure Accept(Socket: TSocket); virtual;
  92.     procedure Connect(Socket: TSocket); virtual;
  93.     procedure Disconnect(Socket: TSocket); virtual;
  94.     procedure Read(Socket: TSocket); virtual;
  95.     procedure Write(Socket: TSocket); virtual;
  96.     function LookupName(const name: string): TInAddr;
  97.     function LookupService(const service: string): Integer;
  98.  
  99.     function ReceiveLength: Integer;
  100.     function ReceiveBuf(var Buf; Count: Integer): Integer;
  101.     function ReceiveText: string;
  102.     function SendBuf(var Buf; Count: Integer): Integer;
  103.     function SendStream(AStream: TStream): Boolean;
  104.     function SendStreamThenDrop(AStream: TStream): Boolean;
  105.     function SendText(const S: string): Integer;
  106.  
  107.     property LocalHost: string;
  108.     property LocalAddress: string;
  109.     property LocalPort: Integer;
  110.  
  111.     property RemoteHost: string;
  112.     property RemoteAddress: string;
  113.     property RemotePort: Integer;
  114.     property RemoteAddr: TSockAddrIn;
  115.  
  116.     property Connected: Boolean;
  117.     property Addr: TSockAddrIn;
  118.     property ASyncStyles: TAsyncStyles;
  119.     property Handle: HWnd;
  120.     property SocketHandle: TSocket;
  121.     property LookupState: TLookupState;
  122.  
  123.     property OnSocketEvent: TSocketEventEvent;
  124.     property OnErrorEvent: TSocketErrorEvent;
  125.  
  126.     property Data: Pointer;
  127.   end;
  128.  
  129.   TClientWinSocket = class(TCustomWinSocket)
  130.   protected
  131.     procedure SetClientType(Value: TClientType);
  132.   public
  133.     procedure Connect(Socket: TSocket); override;
  134.     property ClientType: TClientType;
  135.   end;
  136.  
  137.   TServerClientWinSocket = class(TCustomWinSocket)
  138.   public
  139.     constructor Create(Socket: TSocket; ServerWinSocket: TServerWinSocket);
  140.     destructor Destroy; override;
  141.  
  142.     property ServerWinSocket: TServerWinSocket;
  143.   end;
  144.  
  145.   TThreadNotifyEvent = procedure (Sender: TObject;
  146.     Thread: TServerClientThread) of object;
  147.  
  148.   TServerWinSocket = class(TCustomWinSocket)
  149.   protected
  150.     function DoCreateThread(ClientSocket: TServerClientWinSocket): TServerClientThread; virtual;
  151.     procedure Listen(var Name, Address, Service: string; Port: Word;
  152.       QueueSize: Integer);
  153.     procedure SetServerType(Value: TServerType);
  154.     procedure SetThreadCacheSize(Value: Integer);
  155.     procedure ThreadEnd(AThread: TServerClientThread); dynamic;
  156.     procedure ThreadStart(AThread: TServerClientThread); dynamic;
  157.     function GetClientSocket(Socket: TSocket): TServerClientWinSocket; dynamic;
  158.     function GetServerThread(ClientSocket: TServerClientWinSocket): TServerClientThread; dynamic;
  159.     procedure ClientRead(Socket: TCustomWinSocket); dynamic;
  160.     procedure ClientWrite(Socket: TCustomWinSOcket); dynamic;
  161.     procedure ClientConnect(Socket: TCustomWinSOcket); dynamic;
  162.     procedure ClientDisconnect(Socket: TCustomWinSOcket); dynamic;
  163.     procedure ClientErrorEvent(Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
  164.       var ErrorCode: Integer); dynamic;
  165.   public
  166.     constructor Create(ASocket: TSocket);
  167.     destructor Destroy; override;
  168.     procedure Accept(Socket: TSocket); override;
  169.     procedure Disconnect(Socket: TSocket); override;
  170.     function GetClientThread(ClientSocket: TServerClientWinSocket): TServerClientThread;
  171.     property ActiveConnections: Integer;
  172.     property ActiveT;
  173.     property Connections[Index: Integer]: TCustomWinSocket;
  174.     property IdleT;
  175.     property ServerType: TServerType;
  176.     property T;
  177.     property OnGetSocket: TGetSocketEvent;
  178.     property OnGetT;
  179.     property OnT;
  180.     property OnT;
  181.     property OnClientConnect: TSocketNotifyEvent;
  182.     property OnClientDisconnect: TSocketNotifyEvent;
  183.     property OnClientRead: TSocketNotifyEvent;
  184.     property OnClientWrite: TSocketNotifyEvent;
  185.     property OnClientError: TSocketErrorEvent;
  186.   end;
  187.  
  188.   TServerAcceptThread = class(TThread)
  189.   public
  190.     constructor Create(CreateSuspended: Boolean; ASocket: TServerWinSocket);
  191.     procedure Execute; override;
  192.  
  193.     property ServerSocket: TServerWinSocket;
  194.   end;
  195.  
  196.   TServerClientThread = class(TThread)
  197.   protected
  198.     procedure DoTerminate; override;
  199.     procedure Execute; override;
  200.     procedure ClientExecute; virtual;
  201.     procedure Event(SocketEvent: TSocketEvent); virtual;
  202.     procedure Error(ErrorEvent: TErrorEvent; var ErrorCode: Integer); virtual;
  203.     procedure HandleException; virtual;
  204.     procedure ReActivate(ASocket: TServerClientWinSocket);
  205.     function StartConnect: Boolean;
  206.     function EndConnect: Boolean;
  207.   public
  208.     constructor Create(CreateSuspended: Boolean; ASocket: TServerClientWinSocket);
  209.     destructor Destroy; override;
  210.  
  211.     property ClientSocket: TServerClientWinSocket;
  212.     property ServerSocket: TServerWinSocket;
  213.     property KeepInCache: Boolean;
  214.     property Data: Pointer;
  215.   end;
  216.  
  217.   TAbstractSocket = class(TComponent)
  218.   protected
  219.     procedure Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent);
  220.       virtual; abstract;
  221.     procedure Error(Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
  222.       var ErrorCode: Integer); virtual; abstract;
  223.     procedure DoActivate(Value: Boolean); virtual; abstract;
  224.     procedure InitSocket(Socket: TCustomWinSocket);
  225.     procedure Loaded; override;
  226.     procedure SetActive(Value: Boolean);
  227.     procedure SetAddress(Value: string);
  228.     procedure SetHost(Value: string);
  229.     procedure SetPort(Value: Integer);
  230.     procedure SetService(Value: string);
  231.     property Active: Boolean;
  232.     property Address: string;
  233.     property Host: string;
  234.     property Port: Integer;
  235.     property Service: string;
  236.   public
  237.     procedure Open;
  238.     procedure Close;
  239.   end;
  240.  
  241.   TCustomSocket = class(TAbstractSocket)
  242.   protected
  243.     procedure Event(Socket: TCustomWinSocket; SocketEvent: TSocketEvent); override;
  244.     procedure Error(Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
  245.       var ErrorCode: Integer); override;
  246.     property OnLookup: TSocketNotifyEvent;
  247.     property OnConnecting: TSocketNotifyEvent;
  248.     property OnConnect: TSocketNotifyEvent;
  249.     property OnDisconnect: TSocketNotifyEvent;
  250.     property OnListen: TSocketNotifyEvent;
  251.     property OnAccept: TSocketNotifyEvent;
  252.     property OnRead: TSocketNotifyEvent;
  253.     property OnWrite: TSocketNotifyEvent;
  254.     property OnError: TSocketErrorEvent;
  255.   end;
  256.  
  257.   TWinSocketStream = class(TStream)
  258.   public
  259.     constructor Create(ASocket: TCustomWinSocket; TimeOut: Longint);
  260.     destructor Destroy; override;
  261.     function WaitForData(Timeout: Longint): Boolean;
  262.     function Read(var Buffer; Count: Longint): Longint; override;
  263.     function Write(const Buffer; Count: Longint): Longint; override;
  264.     function Seek(Offset: Longint; Origin: Word): Longint; override;
  265.     property TimeOut: Longint;
  266.   end;
  267.  
  268.   TClientSocket = class(TCustomSocket)
  269.   protected
  270.     procedure DoActivate(Value: Boolean); override;
  271.     function GetClientType: TClientType;
  272.     procedure SetClientType(Value: TClientType);
  273.   public
  274.     constructor Create(AOwner: TComponent); override;
  275.     destructor Destroy; override;
  276.     property Socket: TClientWinSocket;
  277.   published
  278.     property Active;
  279.     property Address;
  280.     property ClientType: TClientType;
  281.     property Host;
  282.     property Port;
  283.     property Service;
  284.     property OnLookup;
  285.     property OnConnecting;
  286.     property OnConnect;
  287.     property OnDisconnect;
  288.     property OnRead;
  289.     property OnWrite;
  290.     property OnError;
  291.   end;
  292.  
  293.   TCustomServerSocket = class(TCustomSocket)
  294.   protected
  295.     FServerSocket: TServerWinSocket;
  296.     procedure DoActivate(Value: Boolean); override;
  297.     function GetServerType: TServerType;
  298.     function GetGetThreadEvent: TGetThreadEvent;
  299.     function GetGetSocketEvent: TGetSocketEvent;
  300.     function GetThreadCacheSize: Integer;
  301.     function GetOnThreadStart: TThreadNotifyEvent;
  302.     function GetOnThreadEnd: TThreadNotifyEvent;
  303.     function GetOnClientEvent(Index: Integer): TSocketNotifyEvent;
  304.     function GetOnClientError: TSocketErrorEvent;
  305.     procedure SetServerType(Value: TServerType);
  306.     procedure SetGetThreadEvent(Value: TGetThreadEvent);
  307.     procedure SetGetSocketEvent(Value: TGetSocketEvent);
  308.     procedure SetThreadCacheSize(Value: Integer);
  309.     procedure SetOnThreadStart(Value: TThreadNotifyEvent);
  310.     procedure SetOnThreadEnd(Value: TThreadNotifyEvent);
  311.     procedure SetOnClientEvent(Index: Integer; Value: TSocketNotifyEvent);
  312.     procedure SetOnClientError(Value: TSocketErrorEvent);
  313.     property ServerType: TServerType;
  314.     property T;
  315.     property OnGetT;
  316.     property OnGetSocket: TGetSocketEvent;
  317.     property OnT;
  318.     property OnT;
  319.     property OnClientConnect: TSocketNotifyEvent index 2;
  320.     property OnClientDisconnect: TSocketNotifyEvent index 3;
  321.     property OnClientRead: TSocketNotifyEvent index 0;
  322.     property OnClientWrite: TSocketNotifyEvent index 1;
  323.     property OnClientError: TSocketErrorEvent;
  324.   public
  325.     destructor Destroy; override;
  326.   end;
  327.  
  328.   TServerSocket = class(TCustomServerSocket)
  329.   public
  330.     constructor Create(AOwner: TComponent); override;
  331.     property Socket: TServerWinSocket;
  332.   published
  333.     property Active;
  334.     property Port;
  335.     property Service;
  336.     property ServerType;
  337.     property ThreadCacheSize default 10;
  338.     property OnListen;
  339.     property OnAccept;
  340.     property OnGetThread;
  341.     property OnGetSocket;
  342.     property OnThreadStart;
  343.     property OnThreadEnd;
  344.     property OnClientConnect;
  345.     property OnClientDisconnect;
  346.     property OnClientRead;
  347.     property OnClientWrite;
  348.     property OnClientError;
  349.   end;
  350.  
  351.   TSocketErrorProc = procedure (ErrorCode: Integer);
  352.  
  353. function SetErrorProc(ErrorProc: TSocketErrorProc): TSocketErrorProc;
  354.  
  355. implementation
  356.